.TH std::ranges::replace_copy,std::ranges::replace_copy_if,std::ranges::replace_copy_result, 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::ranges::replace_copy,std::ranges::replace_copy_if,std::ranges::replace_copy_result, \- std::ranges::replace_copy,std::ranges::replace_copy_if,std::ranges::replace_copy_result,

.SH Synopsis

Defined in header <algorithm>
Call signature
template< std::input_iterator I, std::sentinel_for<I>
S, class T1, class T2,

          std::output_iterator<const T2&> O, class
Proj = std::identity >
requires std::indirectly_copyable<I, O> &&                     (since
         std::indirect_binary_predicate                        C++20)
             <ranges::equal_to, std::projected<I,              (until
Proj>, const T1*>                                              C++26)
constexpr replace_copy_result<I, O>
    replace_copy( I first, S last, O result, const T1&
old_value,

                  const T2& new_value, Proj proj = {}
);
template< std::input_iterator I, std::sentinel_for<I>
S,

          class O, class Proj = std::identity,
          class T1 = std::projected_value_t<I, Proj>,
          class T2 = std::iter_value_t<O> >
requires std::indirectly_copyable<I, O> &&
         std::indirect_binary_predicate                        (since
             <ranges::equal_to, std::projected<I,              C++26)
Proj>, const T1*> &&
         std::output_iterator<O, const T2&>
constexpr replace_copy_result<I, O>
    replace_copy( I first, S last, O result, const T1&
old_value,

                  const T2& new_value, Proj proj = {}
);
template< ranges::input_range R, class T1, class T2,

          std::output_iterator<const T2&> O, class
Proj = std::identity >
requires
std::indirectly_copyable<ranges::iterator_t<R>, O> &&
         std::indirect_binary_predicate                               (since
             <ranges::equal_to,                                       C++20)
              std::projected<ranges::iterator_t<R>,                   (until
Proj>, const T1*>                                                     C++26)
constexpr
replace_copy_result<ranges::borrowed_iterator_t<R>, O>
    replace_copy( R&& r, O result, const T1&
old_value,

                  const T2& new_value, Proj proj = {}
);
template< ranges::input_range R,

          class O, class Proj = std::identity,
          class T1 =
std::projected_value_t<ranges::iterator_t<R>, Proj>,
          class T2 = std::iter_value_t<O> >
requires
std::indirectly_copyable<ranges::iterator_t<R>, O> &&
         std::indirect_binary_predicate
             <ranges::equal_to,                                       (since
              std::projected<ranges::iterator_t<R>,                   C++26)
Proj>, const T1*> &&
         std::output_iterator<O, const T2&>
constexpr
replace_copy_result<ranges::borrowed_iterator_t<R>, O>
    replace_copy( R&& r, O result, const T1&
old_value,

                  const T2& new_value, Proj proj = {}
);
template< std::input_iterator I, std::sentinel_for<I>  \fB(1)\fP
S,

          class T, std::output_iterator<const T&> O,
          class Proj = std::identity,
                                                                             (since
std::indirect_unary_predicate<std::projected<I, Proj>>                       C++20)
Pred >                                                                       (until
requires std::indirectly_copyable<I, O>                                      C++26)
constexpr replace_copy_if_result<I, O>
    replace_copy_if( I first, S last, O result, Pred
pred,

                     const T& new_value, Proj proj =
{} );
template< std::input_iterator I, std::sentinel_for<I>
S,                                                         \fB(2)\fP

          class O, class T = std::iter_value_t<O>
          class Proj = std::identity,

std::indirect_unary_predicate<std::projected<I, Proj>>
Pred >                                                                       (since
requires std::indirectly_copyable<I, O> &&                                   C++26)
std::output_iterator<O, const T&>
constexpr replace_copy_if_result<I, O>
    replace_copy_if( I first, S last, O result, Pred
pred,

                     const T& new_value, Proj proj =
{} );
template< ranges::input_range R,

          class T, std::output_iterator<const T&> O,
          class Proj = std::identity,
          std::indirect_unary_predicate                        \fB(3)\fP
              <std::projected<ranges::iterator_t<R>,
Proj>> Pred >                                                                       (since
requires                                                                            C++20)
std::indirectly_copyable<ranges::iterator_t<R>, O>                                  (until
constexpr                                                                           C++26)
replace_copy_if_result<ranges::borrowed_iterator_t<R>,
O>
    replace_copy_if( R&& r, O result, Pred pred,

                     const T& new_value, Proj proj =
{} );
template< ranges::input_range R,

          class O, class T = std::iter_value_t<O>
          class Proj = std::identity,                                 \fB(4)\fP
          std::indirect_unary_predicate
              <std::projected<ranges::iterator_t<R>,
Proj>> Pred >
requires                                                                            (since
std::indirectly_copyable<ranges::iterator_t<R>, O> &&                               C++26)
         std::output_iterator<O, const T&>
constexpr
replace_copy_if_result<ranges::borrowed_iterator_t<R>,
O>
    replace_copy_if( R&& r, O result, Pred pred,

                     const T& new_value, Proj proj =
{} );
.SH Helper types
template< class I, class O >                                                        (since
using replace_copy_result = ranges::in_out_result<I,                         \fB(5)\fP    C++20)
O>;
template< class I, class O >                                                        (since
using replace_copy_if_result =                                               \fB(6)\fP    C++20)
ranges::in_out_result<I, O>;

   Copies the elements from the source range [first, last) to the destination range
   beginning at result, replacing all elements satisfying specific criteria with
   new_value. The behavior is undefined if the source and destination ranges overlap.

   1) Replaces all elements that are equal to old_value, using std::invoke(proj,
   *(first + (i - result))) == old_value to compare.
   3) Replaces all elements for which the predicate pred evaluates to true, where the
   evaluating expression is std::invoke(pred, std::invoke(proj, *(first + (i -
   result)))).
   2,4) Same as (1,3), but uses r as the source range, as if using ranges::begin(r) as
   first, and ranges::end(r) as last.

   The function-like entities described on this page are niebloids, that is:

     * Explicit template argument lists cannot be specified when calling any of them.
     * None of them are visible to argument-dependent lookup.
     * When any of them are found by normal unqualified lookup as the name to the left
       of the function-call operator, argument-dependent lookup is inhibited.

   In practice, they may be implemented as function objects, or with special compiler
   extensions.

.SH Parameters

   first, last - the range of elements to copy
   r           - the range of elements to copy
   result      - the beginning of the destination range
   old_value   - the value of elements to replace
   new_value   - the value to use as a replacement
   pred        - predicate to apply to the projected elements
   proj        - projection to apply to the elements.

.SH Return value

   {last, result + N}, where

   1,3) N = ranges::distance(first, last);
   2,4) N = ranges::distance(r).

.SH Complexity

   Exactly N applications of the corresponding predicate comp and any projection proj.

.SH Possible implementation

                                    replace_copy (1,2)
 struct replace_copy_fn
 {
     template<std::input_iterator I, std::sentinel_for<I> S,
              class O, class Proj = std::identity,
              class T1 = std::projected_value_t<I, Proj>,
              class T2 = std::iter_value_t<O>>
     requires std::indirectly_copyable<I, O> &&
              std::indirect_binary_predicate
                  <ranges::equal_to, std::projected<I, Proj>, const T1*> &&
              std::output_iterator<O, const T2&>
     constexpr ranges::replace_copy_result<I, O>
         operator()(I first, S last, O result, const T1& old_value,
                    const T2& new_value, Proj proj = {}) const
     {
         for (; first != last; ++first, ++result)
             *result = (std::invoke(proj, *first) == old_value) ? new_value : *first;
         return {std::move(first), std::move(result)};
     }

     template<ranges::input_range R, class O, class Proj = std::identity,
              class T1 = std::projected_value_t<ranges::iterator_t<R>, Proj>,
              class T2 = std::iter_value_t<O>>
     requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
              std::indirect_binary_predicate
                  <ranges::equal_to,
                   std::projected<ranges::iterator_t<R>, Proj>, const T1*>
     constexpr ranges::replace_copy_result<ranges::borrowed_iterator_t<R>, O>
         operator()(R&& r, O result, const T1& old_value,
                    const T2& new_value, Proj proj = {}) const
     {
         return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                        old_value, new_value, std::move(proj));
     }
 };

 inline constexpr replace_copy_fn replace_copy {};
                                   replace_copy_if (3,4)
 struct replace_copy_if_fn
 {
     template<std::input_iterator I, std::sentinel_for<I> S,
              class O, class T = std::iter_value_t<O>
              class Proj = std::identity,
              std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
     requires std::indirectly_copyable<I, O> && std::output_iterator<O, const T&>
     constexpr ranges::replace_copy_if_result<I, O>
         operator()(I first, S last, O result, Pred pred,
                    const T& new_value, Proj proj = {}) const
     {
         for (; first != last; ++first, ++result)
              *result = std::invoke(pred, std::invoke(proj, *first)) ? new_value : *first;
         return {std::move(first), std::move(result)};
     }

     template<ranges::input_range R, class O, class T = std::iter_value_t<O>
              class Proj = std::identity,
              std::indirect_unary_predicate
                  <std::projected<ranges::iterator_t<R>, Proj>> Pred>
     requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
              std::output_iterator<O, const T&>
     constexpr ranges::replace_copy_if_result<ranges::borrowed_iterator_t<R>, O>
         operator()(R&& r, O result, Pred pred,
                    const T& new_value, Proj proj = {}) const
     {
         return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                        std::move(pred), new_value, std::move(proj));
     }
 };

 inline constexpr replace_copy_if_fn replace_copy_if {};

.SH Notes

             Feature-test macro           Value    Std              Feature
   __cpp_lib_algorithm_default_value_type 202403 (C++26) list-initialization for
                                                         algorithms (1-4)

.SH Example


// Run this code

 #include <algorithm>
 #include <array>
 #include <complex>
 #include <iostream>
 #include <vector>

 void println(const auto rem, const auto& v)
 {
     for (std::cout << rem << ": "; const auto& e : v)
         std::cout << e << ' ';
     std::cout << '\\n';
 }

 int main()
 {
     std::vector<int> o;

     std::array p{1, 6, 1, 6, 1, 6};
     o.resize(p.size());
     println("p", p);
     std::ranges::replace_copy(p, o.begin(), 6, 9);
     println("o", o);

     std::array q{1, 2, 3, 6, 7, 8, 4, 5};
     o.resize(q.size());
     println("q", q);
     std::ranges::replace_copy_if(q, o.begin(), [](int x) { return 5 < x; }, 5);
     println("o", o);

     std::vector<std::complex<short>> r{{1, 3}, {2, 2}, {4, 8}};
     std::vector<std::complex<float>> s(r.size());
     println("r", r);
     #ifdef __cpp_lib_algorithm_default_value_type
         std::ranges::replace_copy(r, s.begin(),
                                   {1, 3}, // T1 gets deduced
                                   {2.2, 4.8}); // T2 gets deduced
     #else
         std::ranges::replace_copy(r, s.begin(),
                                   std::complex<short>{1, 3},
                                   std::complex<float>{2.2, 4.8});
     #endif
     println("s", s);

     std::vector<std::complex<double>> b{{1, 3}, {2, 2}, {4, 8}},
                                       d(b.size());
     println("b", b);
     #ifdef __cpp_lib_algorithm_default_value_type
         std::ranges::replace_copy_if(b, d.begin(),
             [](std::complex<double> z){ return std::abs(z) < 5; },
             {4, 2}); // Possible, since the T is deduced.
     #else
         std::ranges::replace_copy_if(b, d.begin(),
             [](std::complex<double> z){ return std::abs(z) < 5; },
             std::complex<double>{4, 2});
     #endif
     println("d", d);
 }

.SH Output:

 p: 1 6 1 6 1 6
 o: 1 9 1 9 1 9
 q: 1 2 3 6 7 8 4 5
 o: 1 2 3 5 5 5 4 5
 r: (1,3) (2,2) (4,8)
 s: (2.2,4.8) (2,2) (4,8)
 b: (1,3) (2,2) (4,8)
 d: (4,2) (4,2) (4,8)

.SH See also

   ranges::replace    replaces all values satisfying specific criteria with another
   ranges::replace_if value
   (C++20)            (niebloid)
   (C++20)
   replace_copy       copies a range, replacing elements satisfying specific criteria
   replace_copy_if    with another value
                      \fI(function template)\fP
